Chained Field Access Fusion

Overview

This PR teaches the mono-move specializer to recognize chains of struct field borrows — patterns like &s.a.b.c followed by a read or write — and collapse each chain into a single fused instruction. Where the interpreter previously executed one micro-op per field step (each computing an address, materializing a reference, and dispatching back through the run loop), a fused chain now executes as one micro-op that folds the entire path into a single precomputed offset.

Main Changes

New fused IR instructions

The stackless IR gains a family of field chain instructions covering the useful combinations of root (a local, or an existing reference) and terminal action (borrow immutably, borrow mutably, read the value out, or write a value in). Each carries the full field path, so downstream phases see the whole access as one unit. Borrow chains deliberately preserve the immutable/mutable distinction, because a mutable borrow of a local creates a hidden-write channel that later optimization passes (coalescing, copy propagation) must be able to see.

The fusion pass

A new pass runs during destacking, before slot allocation. It scans each block for runs of single-use field borrows that feed directly into one another and ends each run at its terminal use. Key properties:

• Single-use discipline — an intermediate reference consumed by anything other than the next link breaks the chain, so no observable reference ever disappears.
• Gap tolerance with terminal sinking — unrelated instructions may sit between the chain and its terminal; the fused instruction is placed at the terminal's position. This is sound for struct chains because the intermediate steps are pure address computations with no observable effects.
• Enum exclusion — enum variant-field steps are excluded from fusion, because each step carries a tag check that can abort; reordering or merging those checks would change abort behavior.
• Linear-time operation — the pass rewrites blocks with a lazy placement plan and in-place compaction, keeping expected cost proportional to block size.

Enum variant-field access rework

Enum field access micro-ops were restructured into two tiers:

• A uniform fast path: when a field lives at the same offset in every variant, the access needs no tag inspection at all and is emitted as a plain heap read/write at a static offset — the same shape as ordinary struct access.
• A tag-dispatched path: otherwise, the micro-op carries a per-tag offset table; at runtime the tag selects the offset, and a missing entry aborts with a variant mismatch. This replaced an older scratch-slot-plus-dereference lowering for divergent-offset fields, eliminating the scratch mechanism entirely.

All offsets are precomputed as object-relative (the enum tag header is folded in at construction), so the interpreter does no offset arithmetic beyond a single add.

Runtime and gas

• The interpreter gains straightforward handlers for the new micro-ops, sharing one small helper for the tag-dispatch prologue.
• A latent undefined-behavior issue was fixed along the way: an 8-byte move micro-op assumed 8-byte alignment, but size-8 aggregates can legally sit at 4-aligned offsets; the accesses are now explicitly unaligned (free on the targeted architectures).

Testing

• New differential tests cover chain fusion end-to-end, gap-tolerant terminal sinking, divergent enum writes (including the abort-on-wrong-variant paths), and abort-ordering behavior that justifies the enum exclusion.
• All existing differential and unit suites pass with the fusion enabled; golden outputs were regenerated to reflect the fused instruction streams.